
package clima;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Scanner;

/**
 *
 * @author  andres
 */
public class AlgoritmosPronostico {
    int cont = 0;
    float alfa= (float) 0.1;                 
    ArrayList<ForecastValues> valores= new ArrayList<ForecastValues>();
    
    
//    public void ingresarValores(ForecastValues valor){
        
//        valores.add(cont, valor);
//        cont++;
//    }// fin metodo ingresar
    
    public double simpleMovingAverage(ArrayList<Double> a,int n){
       
        double ave = 0;    
        for (int i=a.size()-1;i>=a.size()-n;i--){
            ave = ave + a.get(i);  
        }
    return ave/n;
    }
    /*el metodo doubleMovingAverage recibe un arraylist y el numero n de ultimos elementos que se usaran en el calculo
    */
    
    public double doubleMovingAverage(ArrayList<Double> a,int n){ 
              
        double aver = 0;
        int l=a.size();
        for (int i=l-1;i>=l-n;i--){
            a.remove(i);
            
 //           System.out.print(simpleMovingAverage(a,n));
            aver = aver + simpleMovingAverage(a,n);            
        }
    return aver/n;
    }
    public double ExponentialSmoothing(ArrayList<ForecastValues> valores){
        ForecastValues total1= new ForecastValues(0);
        ForecastValues aux2;
        ForecastValues aux = valores.get(0);
        valores.add(valores.size(),total1);       
        aux.pronostico= aux.reporte;
        valores.set(0, aux);
          
        for (int i = 1; i <valores.size(); i++) {
          
            aux=valores.get(i);
            aux2 = valores.get(i-1);
            aux.pronostico=aux2.pronostico + alfa * (aux2.reporte-aux2.pronostico);
            valores.set(i, aux);
                           
        }
        
        total1= valores.get(valores.size()-1);
        return total1.pronostico;
       
    }//fin  metodo  ExponentialSmoothing
    
      public double DoubleExponentialSmoothing(ArrayList<ForecastValues> valores) {
            ExponentialSmoothing(valores );
            ForecastValues aux1= valores.get(0);
            ForecastValues aux2;
            
            aux1.pronosticoDoubleEx= aux1.pronostico;
            valores.set(0, aux1);
       
           for (int i = 1; i < valores.size(); i++) {
           
            aux1= valores.get(i);
            aux2 = valores.get(i-1);
            aux1.pronosticoDoubleEx = alfa*aux2.pronostico+
                    ((1-alfa)*aux2.pronosticoDoubleEx);
           }
            aux1= valores.get(valores.size()-1);
       
       return aux1.pronosticoDoubleEx;
       }
    
    
  
   
   public double error(int tipoAlgoritmo,ArrayList<ForecastValues> valores){
       
       double sumatoria = 0;
       ForecastValues va;
       
       if (tipoAlgoritmo==1){   //ERROR DE ALGORITMO ExponentialSmoothing
           for (int i = 0; i < valores.size()-1; i++) {
              va= valores.get(i);
              sumatoria = sumatoria + Math.abs((va.reporte-va.pronostico)/va.reporte);     
           }   
           System.out.println(sumatoria);
        }//final  xponentialSmoothing
       
       if (tipoAlgoritmo==2){   //ERROR DE ALGORITMO DoubleExponentialSmoothing
           for (int i = 0; i < valores.size()-1; i++) {
              va= valores.get(i);
              sumatoria = sumatoria + Math.abs((va.pronostico-va.pronosticoDoubleEx)/va.pronostico);     
           }   
           System.out.println(sumatoria);
       }
       
            
       return (sumatoria*100) / valores.size();
   }
   
    
    // Main para probar metodos ExponentialSmoothing y DoubleExponentialSmoothing

     }//fin main      
    
     
